package org.aplombh.java.awcing.basic.graph.minimumSpanningTree.kruskal;

import java.util.Arrays;
import java.util.Scanner;

/**
 * 给定一个 n 个点 m 条边的无向图，图中可能存在重边和自环，边权可能为负数。
 * <p>
 * 求最小生成树的树边权重之和，如果最小生成树不存在则输出 impossible。
 * <p>
 * 给定一张边带权的无向图 G=(V,E)，其中 V 表示图中点的集合，E 表示图中边的集合，n=|V|，m=|E|。
 * <p>
 * 由 V 中的全部 n 个顶点和 E 中 n−1 条边构成的无向连通子图被称为 G 的一棵生成树，其中边的权值之和最小的生成树被称为无向图 G 的最小生成树。
 * <p>
 * 输入格式
 * 第一行包含两个整数 n 和 m。
 * <p>
 * 接下来 m 行，每行包含三个整数 u,v,w，表示点 u 和点 v 之间存在一条权值为 w 的边。
 * <p>
 * 输出格式
 * 共一行，若存在最小生成树，则输出一个整数，表示最小生成树的树边权重之和，如果最小生成树不存在则输出 impossible。
 * <p>
 * 数据范围
 * 1≤n≤105,
 * 1≤m≤2∗105,
 * 图中涉及边的边权的绝对值均不超过 1000。
 * <p>
 * 输入样例：
 * 4 5
 * 1 2 1
 * 1 3 2
 * 1 4 3
 * 2 3 2
 * 3 4 4
 * 输出样例：
 * 6
 */
public class Kruskal_859 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        Kruskal kruskal = new Kruskal(n,m);
        for (int i = 0; i < m; i++) {
            int a = scanner.nextInt();
            int b = scanner.nextInt();
            int w = scanner.nextInt();
            kruskal.edges[i].a = a;
            kruskal.edges[i].b = b;
            kruskal.edges[i].w = w;
        }
        kruskal.kruskal();
    }
}

class Kruskal {
    public static final int N = 200010;
    int[] p = new int[N];
    Edge[] edges;
    int n;
    int m;

    public Kruskal(int n,int m) {
        edges = new Edge[N];
        for (int i = 0; i < N; i++) {
            p[i] = i; // 初始化并查集，每个边的集合设为它自己
            edges[i] = new Edge();
        }
        this.n = n;
        this.m = m;
    }

    int find(int x) {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }

    void kruskal(){
        // 排序 sort
        Arrays.sort(edges,0,n);
        // 集合的权重之和与边的个数 The sum of the weights and the number of edges in the set
        int res = 0, cnt = 0;
        for (int i = 0; i < m; i++) {
            int a = edges[i].a;
            int b = edges[i].b;
            int w = edges[i].w;

            a = find(a);
            b = find(b);

            if (a != b) {
                p[a] = b; // 添加进同一个集合
                res += w;
                cnt++;
            }
        }
        if (cnt < n - 1) System.out.println("impossible");
        else System.out.println(res);
    }
}

class Edge implements Comparable<Edge> {
    int a, b, w;

    public Edge() {
    }

    @Override
    public int compareTo(Edge e) {
        return this.w - e.w;
    }
}